/*!-----------------------------------------------------------------------------
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * monaco-languages version: 1.6.0(858705e74270e53559a241fdee187e7a6ae53b23)
 * Released under the MIT license
 * https://github.com/Microsoft/monaco-languages/blob/master/LICENSE.md
 *-----------------------------------------------------------------------------*/
define("vs/basic-languages/ruby/ruby", ["require", "exports"], function (e, t) {
  "use strict";
  Object.defineProperty(t, "__esModule", { value: !0 }),
    (t.conf = {
      comments: { lineComment: "#", blockComment: ["=begin", "=end"] },
      brackets: [
        ["(", ")"],
        ["{", "}"],
        ["[", "]"],
      ],
      autoClosingPairs: [
        { open: "{", close: "}" },
        { open: "[", close: "]" },
        { open: "(", close: ")" },
        { open: '"', close: '"' },
        { open: "'", close: "'" },
      ],
      surroundingPairs: [
        { open: "{", close: "}" },
        { open: "[", close: "]" },
        { open: "(", close: ")" },
        { open: '"', close: '"' },
        { open: "'", close: "'" },
      ],
    }),
    (t.language = {
      tokenPostfix: ".ruby",
      keywords: [
        "__LINE__",
        "__ENCODING__",
        "__FILE__",
        "BEGIN",
        "END",
        "alias",
        "and",
        "begin",
        "break",
        "case",
        "class",
        "def",
        "defined?",
        "do",
        "else",
        "elsif",
        "end",
        "ensure",
        "for",
        "false",
        "if",
        "in",
        "module",
        "next",
        "nil",
        "not",
        "or",
        "redo",
        "rescue",
        "retry",
        "return",
        "self",
        "super",
        "then",
        "true",
        "undef",
        "unless",
        "until",
        "when",
        "while",
        "yield",
      ],
      keywordops: ["::", "..", "...", "?", ":", "=>"],
      builtins: [
        "require",
        "public",
        "private",
        "include",
        "extend",
        "attr_reader",
        "protected",
        "private_class_method",
        "protected_class_method",
        "new",
      ],
      declarations: [
        "module",
        "class",
        "def",
        "case",
        "do",
        "begin",
        "for",
        "if",
        "while",
        "until",
        "unless",
      ],
      linedecls: [
        "def",
        "case",
        "do",
        "begin",
        "for",
        "if",
        "while",
        "until",
        "unless",
      ],
      operators: [
        "^",
        "&",
        "|",
        "<=>",
        "==",
        "===",
        "!~",
        "=~",
        ">",
        ">=",
        "<",
        "<=",
        "<<",
        ">>",
        "+",
        "-",
        "*",
        "/",
        "%",
        "**",
        "~",
        "+@",
        "-@",
        "[]",
        "[]=",
        "`",
        "+=",
        "-=",
        "*=",
        "**=",
        "/=",
        "^=",
        "%=",
        "<<=",
        ">>=",
        "&=",
        "&&=",
        "||=",
        "|=",
      ],
      brackets: [
        { open: "(", close: ")", token: "delimiter.parenthesis" },
        { open: "{", close: "}", token: "delimiter.curly" },
        { open: "[", close: "]", token: "delimiter.square" },
      ],
      symbols: /[=><!~?:&|+\-*\/\^%\.]+/,
      escape:
        /(?:[abefnrstv\\"'\n\r]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4})/,
      escapes: /\\(?:C\-(@escape|.)|c(@escape|.)|@escape)/,
      decpart: /\d(_?\d)*/,
      decimal: /0|@decpart/,
      delim: /[^a-zA-Z0-9\s\n\r]/,
      heredelim: /(?:\w+|'[^']*'|"[^"]*"|`[^`]*`)/,
      regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
      regexpesc:
        /\\(?:[AzZbBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})?/,
      tokenizer: {
        root: [
          [
            /^(\s*)([a-z_]\w*[!?=]?)/,
            [
              "white",
              {
                cases: {
                  "for|until|while": {
                    token: "keyword.$2",
                    next: "@dodecl.$2",
                  },
                  "@declarations": { token: "keyword.$2", next: "@root.$2" },
                  end: { token: "keyword.$S2", next: "@pop" },
                  "@keywords": "keyword",
                  "@builtins": "predefined",
                  "@default": "identifier",
                },
              },
            ],
          ],
          [
            /[a-z_]\w*[!?=]?/,
            {
              cases: {
                "if|unless|while|until": {
                  token: "keyword.$0x",
                  next: "@modifier.$0x",
                },
                for: { token: "keyword.$2", next: "@dodecl.$2" },
                "@linedecls": { token: "keyword.$0", next: "@root.$0" },
                end: { token: "keyword.$S2", next: "@pop" },
                "@keywords": "keyword",
                "@builtins": "predefined",
                "@default": "identifier",
              },
            },
          ],
          [/[A-Z][\w]*[!?=]?/, "constructor.identifier"],
          [/\$[\w]*/, "global.constant"],
          [/@[\w]*/, "namespace.instance.identifier"],
          [/@@[\w]*/, "namespace.class.identifier"],
          [
            /<<[-~](@heredelim).*/,
            { token: "string.heredoc.delimiter", next: "@heredoc.$1" },
          ],
          [
            /[ \t\r\n]+<<(@heredelim).*/,
            { token: "string.heredoc.delimiter", next: "@heredoc.$1" },
          ],
          [
            /^<<(@heredelim).*/,
            { token: "string.heredoc.delimiter", next: "@heredoc.$1" },
          ],
          { include: "@whitespace" },
          [/"/, { token: "string.d.delim", next: '@dstring.d."' }],
          [/'/, { token: "string.sq.delim", next: "@sstring.sq" }],
          [/%([rsqxwW]|Q?)/, { token: "@rematch", next: "pstring" }],
          [/`/, { token: "string.x.delim", next: "@dstring.x.`" }],
          [/:(\w|[$@])\w*[!?=]?/, "string.s"],
          [/:"/, { token: "string.s.delim", next: '@dstring.s."' }],
          [/:'/, { token: "string.s.delim", next: "@sstring.s" }],
          [
            /\/(?=(\\\/|[^\/\n])+\/)/,
            { token: "regexp.delim", next: "@regexp" },
          ],
          [/[{}()\[\]]/, "@brackets"],
          [
            /@symbols/,
            {
              cases: {
                "@keywordops": "keyword",
                "@operators": "operator",
                "@default": "",
              },
            },
          ],
          [/[;,]/, "delimiter"],
          [/0[xX][0-9a-fA-F](_?[0-9a-fA-F])*/, "number.hex"],
          [/0[_oO][0-7](_?[0-7])*/, "number.octal"],
          [/0[bB][01](_?[01])*/, "number.binary"],
          [/0[dD]@decpart/, "number"],
          [
            /@decimal((\.@decpart)?([eE][\-+]?@decpart)?)/,
            { cases: { $1: "number.float", "@default": "number" } },
          ],
        ],
        dodecl: [
          [/^/, { token: "", switchTo: "@root.$S2" }],
          [
            /[a-z_]\w*[!?=]?/,
            {
              cases: {
                end: { token: "keyword.$S2", next: "@pop" },
                do: { token: "keyword", switchTo: "@root.$S2" },
                "@linedecls": { token: "@rematch", switchTo: "@root.$S2" },
                "@keywords": "keyword",
                "@builtins": "predefined",
                "@default": "identifier",
              },
            },
          ],
          { include: "@root" },
        ],
        modifier: [
          [/^/, "", "@pop"],
          [
            /[a-z_]\w*[!?=]?/,
            {
              cases: {
                end: { token: "keyword.$S2", next: "@pop" },
                "then|else|elsif|do": {
                  token: "keyword",
                  switchTo: "@root.$S2",
                },
                "@linedecls": { token: "@rematch", switchTo: "@root.$S2" },
                "@keywords": "keyword",
                "@builtins": "predefined",
                "@default": "identifier",
              },
            },
          ],
          { include: "@root" },
        ],
        sstring: [
          [/[^\\']+/, "string.$S2"],
          [/\\\\|\\'|\\$/, "string.$S2.escape"],
          [/\\./, "string.$S2.invalid"],
          [/'/, { token: "string.$S2.delim", next: "@pop" }],
        ],
        dstring: [
          [/[^\\`"#]+/, "string.$S2"],
          [/#/, "string.$S2.escape", "@interpolated"],
          [/\\$/, "string.$S2.escape"],
          [/@escapes/, "string.$S2.escape"],
          [/\\./, "string.$S2.escape.invalid"],
          [
            /[`"]/,
            {
              cases: {
                "$#==$S3": { token: "string.$S2.delim", next: "@pop" },
                "@default": "string.$S2",
              },
            },
          ],
        ],
        heredoc: [
          [
            /^(\s*)(@heredelim)$/,
            {
              cases: {
                "$2==$S2": [
                  "string.heredoc",
                  { token: "string.heredoc.delimiter", next: "@pop" },
                ],
                "@default": ["string.heredoc", "string.heredoc"],
              },
            },
          ],
          [/.*/, "string.heredoc"],
        ],
        interpolated: [
          [/\$\w*/, "global.constant", "@pop"],
          [/@\w*/, "namespace.class.identifier", "@pop"],
          [/@@\w*/, "namespace.instance.identifier", "@pop"],
          [
            /[{]/,
            {
              token: "string.escape.curly",
              switchTo: "@interpolated_compound",
            },
          ],
          ["", "", "@pop"],
        ],
        interpolated_compound: [
          [/[}]/, { token: "string.escape.curly", next: "@pop" }],
          { include: "@root" },
        ],
        pregexp: [
          { include: "@whitespace" },
          [
            /[^\(\{\[\\]/,
            {
              cases: {
                "$#==$S3": { token: "regexp.delim", next: "@pop" },
                "$#==$S2": { token: "regexp.delim", next: "@push" },
                "~[)}\\]]": "@brackets.regexp.escape.control",
                "~@regexpctl": "regexp.escape.control",
                "@default": "regexp",
              },
            },
          ],
          { include: "@regexcontrol" },
        ],
        regexp: [
          { include: "@regexcontrol" },
          [/[^\\\/]/, "regexp"],
          ["/[ixmp]*", { token: "regexp.delim" }, "@pop"],
        ],
        regexcontrol: [
          [
            /(\{)(\d+(?:,\d*)?)(\})/,
            [
              "@brackets.regexp.escape.control",
              "regexp.escape.control",
              "@brackets.regexp.escape.control",
            ],
          ],
          [
            /(\[)(\^?)/,
            [
              "@brackets.regexp.escape.control",
              { token: "regexp.escape.control", next: "@regexrange" },
            ],
          ],
          [
            /(\()(\?[:=!])/,
            ["@brackets.regexp.escape.control", "regexp.escape.control"],
          ],
          [/\(\?#/, { token: "regexp.escape.control", next: "@regexpcomment" }],
          [/[()]/, "@brackets.regexp.escape.control"],
          [/@regexpctl/, "regexp.escape.control"],
          [/\\$/, "regexp.escape"],
          [/@regexpesc/, "regexp.escape"],
          [/\\\./, "regexp.invalid"],
          [/#/, "regexp.escape", "@interpolated"],
        ],
        regexrange: [
          [/-/, "regexp.escape.control"],
          [/\^/, "regexp.invalid"],
          [/\\$/, "regexp.escape"],
          [/@regexpesc/, "regexp.escape"],
          [/[^\]]/, "regexp"],
          [/\]/, "@brackets.regexp.escape.control", "@pop"],
        ],
        regexpcomment: [
          [/[^)]+/, "comment"],
          [/\)/, { token: "regexp.escape.control", next: "@pop" }],
        ],
        pstring: [
          [
            /%([qws])\(/,
            { token: "string.$1.delim", switchTo: "@qstring.$1.(.)" },
          ],
          [
            /%([qws])\[/,
            { token: "string.$1.delim", switchTo: "@qstring.$1.[.]" },
          ],
          [
            /%([qws])\{/,
            { token: "string.$1.delim", switchTo: "@qstring.$1.{.}" },
          ],
          [
            /%([qws])</,
            { token: "string.$1.delim", switchTo: "@qstring.$1.<.>" },
          ],
          [
            /%([qws])(@delim)/,
            { token: "string.$1.delim", switchTo: "@qstring.$1.$2.$2" },
          ],
          [/%r\(/, { token: "regexp.delim", switchTo: "@pregexp.(.)" }],
          [/%r\[/, { token: "regexp.delim", switchTo: "@pregexp.[.]" }],
          [/%r\{/, { token: "regexp.delim", switchTo: "@pregexp.{.}" }],
          [/%r</, { token: "regexp.delim", switchTo: "@pregexp.<.>" }],
          [/%r(@delim)/, { token: "regexp.delim", switchTo: "@pregexp.$1.$1" }],
          [
            /%(x|W|Q?)\(/,
            { token: "string.$1.delim", switchTo: "@qqstring.$1.(.)" },
          ],
          [
            /%(x|W|Q?)\[/,
            { token: "string.$1.delim", switchTo: "@qqstring.$1.[.]" },
          ],
          [
            /%(x|W|Q?)\{/,
            { token: "string.$1.delim", switchTo: "@qqstring.$1.{.}" },
          ],
          [
            /%(x|W|Q?)</,
            { token: "string.$1.delim", switchTo: "@qqstring.$1.<.>" },
          ],
          [
            /%(x|W|Q?)(@delim)/,
            { token: "string.$1.delim", switchTo: "@qqstring.$1.$2.$2" },
          ],
          [/%([rqwsxW]|Q?)./, { token: "invalid", next: "@pop" }],
          [/./, { token: "invalid", next: "@pop" }],
        ],
        qstring: [
          [/\\$/, "string.$S2.escape"],
          [/\\./, "string.$S2.escape"],
          [
            /./,
            {
              cases: {
                "$#==$S4": { token: "string.$S2.delim", next: "@pop" },
                "$#==$S3": { token: "string.$S2.delim", next: "@push" },
                "@default": "string.$S2",
              },
            },
          ],
        ],
        qqstring: [
          [/#/, "string.$S2.escape", "@interpolated"],
          { include: "@qstring" },
        ],
        whitespace: [
          [/[ \t\r\n]+/, ""],
          [/^\s*=begin\b/, "comment", "@comment"],
          [/#.*$/, "comment"],
        ],
        comment: [
          [/[^=]+/, "comment"],
          [/^\s*=begin\b/, "comment.invalid"],
          [/^\s*=end\b.*/, "comment", "@pop"],
          [/[=]/, "comment"],
        ],
      },
    });
});
